
/*
	功能：生成一个指定区间的随机整数，并以返回值返回
	参数1 start:代表指定区间的下限
	参数2 end:代表指定区间的上限
	返回值 result:代表生成的随机整数
*/
function CreatRandomNumer(start, end){
	//result代表生成的随机数
	var result = parseInt(Math.random() * (strat - end) + start);
	return result;	
}



/*
	1.传入一个年份参数，判断某年是否为闰年
	功能：判断某年是否为闰年
	参数：接收一个年份作为参数
	返回值：true(闰年)/false(平年)
*/
function isLeapYear(year){
	if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
		return true;
	}
	else{
		return false;
	}
}



/*
	2.传入一个日期参数，传入一个相连符号，进行日期格式化
	功能：将传入的日期按照传入的字符进行格式化
	参数1：需要格式化的日期作为参数,此参数的类型的必须是Date对象
	参数2：指定的分隔符号参作为数，此参数的类型必须是字符串
	返回值：格式化后的日期
*/
function dateFormat(date,spiltStr){
	//取得传入日期参数的年份
	var year = date.getFullYear();
	//取得传入日期参数的月份
	var month = date.getMonth() + 1;
	//判断当月份小于10时，格式化成月份前加个0
	if(month < 10){
		month = "0" + month;
	}
	//取得传入日期参数的天数
	var day = date.getDate();
	//判断当天数小于10时，格式化成天数前加个0
	if(day < 10){
		day = "0" + day;
	}
	//取得传入日期参数的小时数
	var hour = date.getHours();
	//判断当小时小于10时，格式化成小时前加个0
	if(hour < 10){
		hour = "0" + hour;
	}
	//取得传入日期参数的分钟数
	var minute = date.getMinutes();
	//判断当分钟小于10时，格式化成分钟前加个0
	if(minute < 10){
		minute = "0" + minute;
	}
	//取得传入日期参数的秒数
	var second = date.getSeconds();
	//判断当秒数小于10时，格式化成秒数前加个0
	if(second < 10){
		second = "0" + second;
	}
	//拼接格式化日期
	var dateFormatStr = year + spiltStr + month + spiltStr + day  + " " + hour + ":" + minute + ":" + second;
	return dateFormatStr;
}



/*
	3.传入一个月份参数，获得今年某月的天数
	功能：指定某个月份，获取该月份的总天数
	参数：接收某个月份作为参数
	返回值：计算出来的该月份的总天数
*/
function getEachMonthLength(month){
	//创建一个新的Date对象
	var days = new Date();
	//设置创建的Date对象的月数，但此时为month-1月，因为月份是从0开始的
	days.setMonth(month);
	//设置月份的总天数，因为参数设为0时，返回的是上一个月的总天数
	days.setDate(0);
	var result = days.getDate();
	//返回指定月份的总天数
	return result;
}



/*
	4.传入一个日期字符串参数，将字符串转为日期
	功能：将指定的字符串转换成日期
	参数：时间字符串(采用RFC2822格式)作为参数
	返回值：转换后的日期对象	
*/
function toDate(timeStr){
	var date = new Date(timeStr);
	return date;
}



/*
	5.传入一个天数参数N(都可以)，获得N天后或者N天以前的日期
	参数：指定N天以前则为负数，指定的是N天之后则为负数
	返回值：计算后的时间
	
*/
function addDay(day){
	//获取系统当前时间
	var date = new Date();
	//计算N天后的天数
	var resultDay = date.getDate() + day;
	//利用计算N天后的结果，重新设置天数
	date.setDate(resultDay);
	//返回最终结果
	return dateFormat(date,"-");
}



/*
	6.传入一个起始日期参数，传入一个结束日期参数，计算两个日期差（天、时、分、刚刚）
	参数1：起始的日期作为参数
	参数2：结束的日期作为参数
	返回值：由计算出的最终日期差和添加字符串拼接成的字符串
*/
function dateSpace(startDate,endDate){
	var date1 = new Date(startDate);
	var date2 = new Date(endDate);
	//计算天数差，显示间隔几天
	var daySpace = date2.getDate() - date1.getDate();
	//计算小时差，显示间隔几小时
	var hourSpace = date2.getHours() - date1.getHours();
	//计算分钟差，显示间隔几分钟
	var minuteSpace = date2.getMinutes() - date1.getMinutes();
	//计算1分钟之内的差(即显示:刚刚)
	var secondSpace = date2.getSeconds() - date1.getSeconds();
	if(daySpace > 3){
		var resultStr1 = date1.toLocaleDateString();
		console.log(resultStr1);
		var resultStr2 = new Date(resultStr1);
		var resultStr = dateFormat(resultStr2,"-");
		return resultStr;
	}
	else if(daySpace > 0 && daySpace <= 3){
		var resultstr = daySpace + " 天前";
		return resultstr;
	}
	else if(hourSpace > 0){
		var resultstr = hourSpace + " 小时前";
		return resultstr;
	}
	else if(minuteSpace > 0){
		var resultstr = minuteSpace + " 分钟前";
		return resultstr;
	}
	else if(secondSpace != 0){
		var resultstr = secondSpace + " 秒前";
		return resultstr;
	}
	else{
		var resultstr = "刚刚";
		return resultstr;
	}
}



/*
	功能：解决各大浏览器兼容可视区宽度问题
	返回值：根据各个浏览器的兼容性特点返回各自的兼容的可视区宽度
*/
function getWidth(){
	if(window.innerWidth){
		return window.innerWidth;
	}
	else{

		if(document.compatMode == "CSS1Compat"){
			return document.documentElement.clientWidth;
		}
		else{
			return document.body.clientWidth;
		}
	}
}


/*
	功能：解决各大浏览器兼容可视区高度问题
	返回值：根据各个浏览器的兼容性特点返回各自的兼容的可视区高度
*/
function getHeight(){
	if(window.innerHeight){
		return window.innerHeight;
	}
	else{
		if(document.compatMode == "CSS1Compat"){
			return document.documentElement.clientHeight;
		}
		else{
			return document.body.clientHeight;
		}
	}
}


/*
	功能：获取滚动条的卷曲高度
	返回值：滚动条的卷曲高度
*/
function getScrollTop(){
	return document.documentElement.scrollTop + document.body.scrollTop;
}


/*
	功能：获取一个页面中一个类名的所有标签节点集合
	参数：标签的类名
	返回值：指定类名的HTMLCollection集合
*/
function getClassName(classNameE){
	//先通过getElementsByTagName()获取所有的标签节点
	var listAll = document.getElementsByTagName("*");
	//定义空数组，用于接收要找的标签节点
	var classArr = [];
	//循环遍历取到的HTMLcollection集合
	for(var i=0; i < listAll.length; i++){
		//判断若传过来的类名与得到的集合里面的类名相同，将之放到空数组中
		if(listAll[i].className == classNameE){
			//将找到符合条件的标签放到数组中
			classArr.push(listAll[i]);
		}
	}
	//返回想要获取的HTMLCollection集合
	return classArr;				
}



/*
	功能：按照接收的元素找到其对应的样式属性，并返回对应的样式属性值
	参数1：给定的元素
	参数2：指定的元素的属性
	返回值：指定的元素的属性值
*/
// function getStyle(element,attributeName){
// 	if(element.currentStyle){
// 		return element.currentStyle[attributeName];
// 	}
// 	else{
// 		return window.getComputedStyle(element,null)[attributeName];
// 	}
// }



/*
	功能：接收一个指定元素节点，查找你想要的子节点元素(不需要的过滤掉),
	      最后返回想要的节点元素集合
	参数：父级元素节点
	返回值：找到的子节点元素集合
*/
function getChildNodes(element){
	//获取到父级元素下所有的子节点元素(包括文本节点，换行文本节点)
	var nodesList = element.childNodes;
	//定义空数组用于接收选出来的元素节点
	var nodesArr = [];
	for(var i = 0; i < nodesList.length; i++){
		if(nodesList[i].nodeType == 1){
			nodesArr.push(nodesList[i]);
		}
	}
	//返回找到的所有元素节点
	return nodesArr;
}



/*
	功能：接收一个指定元素节点，查找你想要的子节点元素(不需要的过滤掉),
	      最后返回节点元素集合的第一个子节点
	参数：父级元素节点
	返回值：找到的子节点元素集合中的第一个
*/
function getFirstChildNode(element){
	//获取到父级元素下所有的子节点元素(包括文本节点，换行文本节点)
	var nodesList = element.childNodes;
	//定义一个空对象接收找到的第一个子节点对象
	var firstNodeOBJ = null;
	for(var i = 0; i < nodesList.length; i++){
		if(nodesList[i].nodeType == 1){
			firstNodeOBJ = nodesList[i];
			//找到后立马终止循环，则返回的是第一个子节点；
			//否则，一直循环到最后，那时返回的是最后一个子节点
			break;
		}
	}
	return firstNodeOBJ;
}



/*
	功能：接收一个指定元素节点，查找你想要的子节点元素(不需要的过滤掉),
	       最后返回想要的节点元素集合的最后一个子节点
	参数：父级元素节点
	返回值：找到的子节点元素集合中的最后一个
*/
function getLastChildNode(element){
	//获取到父级元素下所有的子节点元素(包括文本节点，换行文本节点)
	var nodesList = element.childNodes;
	//定义一个空对象接收找到的第一个子节点对象
	var lastNodeOBJ = null;
	//方法1：
	for(var i = nodesList.length - 1; i >= 0; i--){
		if(nodesList[i].nodeType == 1){
			lastNodeOBJ = nodesList[i];
			break;
		}
	}
	/*	方法2：
		for(var i = 0; i < nodesList.length; i++){
			if(nodesList[i].nodeType == 1){
				//此时没有终止循环，一直找到最后一个子节点，循环终止，所以返回的是最后一个子节点
				lastNodeOBJ = nodesList[i];
			}
		}
	*/
	//返回最后一个子节点对象
	return lastNodeOBJ;
}



/*
	功能：给定一个元素节点，获取他的下一个子元素节点(即下一个子节点且为元素节点)
	参数：元素节点
	返回值：1.当给定的元素节点的下一个节点元素不存在元素节点时，返回null
			2.当存在时，返回找到的它的下一个子元素节点(即下一个子节点且为元素节点)
*/
function getNextSibling(element){
	//获取给定的元素节点的下一个节点(有可能是文本节点，也有可能是换行文本节点)
	var nodeOBJ = element.nextSibling;
	//判断是否存在下一子节点以及判断下一个子节点是否是文本节点
	while(nodeOBJ != null && nodeOBJ.nodeType != 1){
		nodeOBJ = nodeOBJ.nextSibling;
	}
	//返回找到的下一个子元素节点(即下一个子节点且为元素节点)
	return nodeOBJ;
}



/*
	功能：给定一个元素节点，获取他的上一个子元素节点(即上一个子节点且为元素节点)
	参数：元素节点
	返回值：1.当给定的元素节点的上一个节点元素不存在元素节点时，返回null
			2.当存在时，返回找到的它的上一个子元素节点(即上一个子节点且为元素节点)
*/
function getPreviousSibling(element){
	//获取给定的元素节点的上一个节点(有可能是文本节点，也有可能是换行文本节点)
	var nodeOBJ = element.previousSibling;
	//判断是否存在上一子节点以及判断上一个子节点是否是文本节点
	while(nodeOBJ != null && nodeOBJ.nodeType != 1){
		nodeOBJ = nodeOBJ.previousSibling;
	}
	//返回找到的上一个子元素节点(即下一个子节点且为元素节点)
	return nodeOBJ;
}


/*
	功能：给定一个集合，单独给选中的集合项设置指定的样式
	参数1：elements代表指定的集合
	参数2：selectedItem代表选中的集合项
	参数3：cssStyleName代表在外部JS文件中设置的CSS样式
	无返回值
*/
function setClassName(elements,selectedItem,cssStyleName){
	for(var i= 0; i < elements.length; i++){
		elements[i].className = cssStyleName;
	}
	selectedItem.className = " ";
}

/*
	功能：避免重复敲"document.getElementById()"的方法
	参数：指定元素节点的ID
	返回：通过给定的ID找到的元素节点对象
*/
function $id(elementIDName){
	var object = document.getElementById(elementIDName);
	return object;
}

/*
	功能：避免重复敲"document.getElementsByTagName()"的方法
	参数：指定元素节点的标签名
	返回：通过给定的元素节点的标签名找到的元素节点对象集合
*/
function $tag(elementIDName){
	var object = document.getElementsByTagName(elementIDName);
	return object;
}

/*
	功能：获取随机颜色
	参数：无
	返回值：生成的十六进制表示的颜色字符串
*/
function getRandomColor(){
	//随机组成十六进制颜色的单个字符
	var colorArr = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"];
	//获取随机的数组colorArr的下标
	var randomArrSub = 0;
	//获取到的随机颜色
	var randomColor = "";
	//循环从colorArr数组中取出6个字符，组成随机颜色
	for(var i = 0; i < 6; i++){
		randomArrSub = parseInt(Math.random() * colorArr.length);
		randomColor += colorArr[randomArrSub];	
	}
	return "'#" + randomColor + "'";
}	


/*
	功能:解决事件源对象兼容性问题
	参数：事件源对象的形参，用于接收浏览器解释器中的事件源对象
	注：IE低版本浏览器会将事件源对象放到window属性event下，
	    而chrome和Firefox则直接将事件源对象传递给形参e
*/
function getEventObj(e){
	e = e || event;
	return e;
}


/*
	功能:获取鼠标相对于页面内容区的X轴坐标
	参数：可视区的宽度
	返回值：鼠标相对与页面内容的X轴坐标
*/
function getPageX(clientX){
	return clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
}


/*
	功能:获取鼠标相对于页面内容区的Y轴坐标
	参数：可视区的高度
	返回值：鼠标相对与页面内容的Y轴坐标
*/
function getPageY(clientY){
	return clientY + document.documentElement.scrollTop + document.body.scrollTop;
}


/*
	功能：DOM2级事件装载事件的兼容写法
	参数1：需要添加函数的元素对象
	参数2：需要加载哪个事件，传参时需要去掉事件前面的on
	参数3：事件处理函数
	参数4：true(代表事件捕获)或false(代表事件冒泡)

*/
function addEvent(element,type,fn,m){
	if(element.addEventListener){
		//非IE装载事件的写法
		element.addEventListener(type,fn,m);
	}
	else{
		//IE装载事件的写法
		element.attachEvent("on" + type,fn);
	}
}


/*
	功能：DOM2级事件卸载事件的兼容写法
	参数1：需要添加函数的元素对象
	参数2：需要卸载哪个事件，传参时需要去掉事件前面的on
	参数3：事件处理函数
	参数4：true(代表事件捕获)或false(代表事件冒泡)

*/
function delEvent(element,type,fn,m){
	if(element.removeEventListener){
		//非IE卸载事件的写法
		element.removeEventListener(type,fn,m);
	}
	else{
		//IE卸载事件的写法
		element.detachEvent("on" + type,fn);
	}
}



/*
	功能：兼容所有浏览器阻止默认行为
	参数：事件源对象
*/
function preventDefault(eObj){
	//非IE下方法
	if(eObj.preventDefault){
		eObj.preventDefault();
	}
	//IE下方法
	else{
		eObj.returnValue = false;
	}
}


/*
	功能：兼容所有浏览器冒泡
	参数：事件源对象
*/
function myStopPropagation(eObj){
	//非IE下方法
	if(eObj.stopPropagation){
		eObj.stopPropagation();
	}
	//IE下方法
	else{
		eObj.cancleBubble = true;
	}
}

/*
	功能：向cookie里存储数据方法
	参数1：key 键名
	参数2：value 键值
	参数3：dateTime 失效时间
*/
function addCookie(key,value,dateTime){
	//向cookieValue中添加(即存储)编码过后的数据
	var cookieValue = key + "=" + encodeURIComponent(value);
	//判断是否设置了失效时间
	if(dateTime){
		//若设置了失效时间，则将失效时间存储到cookieValue中
		var cookieValue = cookieValue + ";expires=" + dateTime;
	}
	//最后将cookieValue的值赋给cookie
	document.cookie = cookieValue;
}


/*
	功能：给定键名，返回键值
	参数：key 给定的键名 
	返回值：给定键名的键值
*/
function getKeyValue(key){
	var cookieObj = document.cookie;
	//用";"分隔符，分割cookieObject中的字符串
	var str = cookieObj.split(";");
	//keyValue用于接收需要返回的键值
	var keyValue = "";
	//循环遍历cookie中的各个键值对
	for(var i = 0; i < str.length; i++){
		//依次将cookie中的键值对以"="号再分割
		var keyName = str[i].split("=")[0];
		//判断键名是否是需要找到的
		if(keyName == key){
			//将找到的键值赋值给keyValue
			keyValue = str[i].split("=")[1];
			break;
		}
	}
	//返回找到的键值
	return keyValue;
}


/*
	功能：删除cookie里的某个键值对
	参数：key 给定的cookie里的键名
*/
function delCookie(key){
	//创建事件对象，通过毫秒数设置时间对象为国际标准时间
	var date = new Date(0);
	document.cookie = key + "=;expires=" + date;
}




/*
	功能：兼容IE6及其他浏览器创建AJAX对象的写法
	返回值：AJAX的对象
*/
function createXHR(){
	if(window.XMLHttpRequest){
		return new XMLHttpRequest();
	}
	else{
		return new ActiveXObject("Microsoft.XMLHTTP");
	}
}

/*
	功能：Ajax的get方式封装
	参数1：url地址
	参数2：回调函数fn
*/
function getAjax(url,callback){
	var xhr = createXHR();
	xhr.open("GET",url,true);
	xhr.onreadystatechange = function(){
		if(xhr.readyState == 4){
			if(xhr.status == 200){
				var data = eval("(" + xhr.responseText + ")");
				callback(data);
			}
		}
	}
	xhr.send(null);
}

/*
	功能：
	参数：get方式的JSONP的地址
*/
function JSONP(url){
	var scriptObj = document.createElement("script");
	scriptObj.src = url;
	document.body.appendChild(scriptObj);
}

/*
	功能：缓冲运动整合整合框架
	参数1：要运动的元素
	参数2：要运动的元素的属性组成的JSON对象
	参数3：是否运动完之后进行下一次运动
	无返回值
	
*/
//缓冲运动整合
// function startMove(element,attrJSON,callback){
// 	clearInterval(element.timer);
// 	element.timer = setInterval(function(){
// 		var attrJSONCount = 0;
// 		var intervalCount = 0;
// 		for(var attrName in attrJSON){
// 			var cur = attrName == "opacity" ? Math.round( getStyle(element,attrName) * 100 ) : parseInt( getStyle(element,attrName) );
// 			var speed = (attrJSON[attrName] - cur) / 5;
// 			speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
// 			if(attrName == "opacity"){
// 				element.style.opacity = (cur + speed) / 100;
// 				element.style.filter = "alpha(opacity=" + (cur + speed) + ")";
// 			}
// 			else{
// 				element.style[attrName] = cur + speed + "px";
// 			}
// 			attrJSONCount++;
// 			if(cur == attrJSON[attrName]){
// 				intervalCount++;	
// 			}
// 		}
// 		if(attrJSONCount == intervalCount){
// 			clearInterval(element.timer);
// 			if(callback){
// 				callback();
// 			}
// 		}	
// 	},60);
// }


